package errors

import (
	"fmt"
	"io"
	"path"
	"runtime"
	"strconv"
	"strings"
)

const _unknown = "unknown"

// Frame 栈帧，从调用者返回的程序计数器中获取 function/file/line 信息，用于构建
// 调用栈，参考[Frames](https://pkg.go.dev/runtime#Frames)。
type Frame uintptr

// pc 由于历史原因，如果 Frame 是 uintptr 类型，它的值是程序计数器（ PC ）值加 1 。
func (f Frame) pc() uintptr { return uintptr(f) - 1 }

// file 通过 PC 返回对应源代码文件的完整路径。
func (f Frame) file() string {
	fn := runtime.FuncForPC(f.pc())
	if fn == nil {
		return _unknown
	}

	file, _ := fn.FileLine(f.pc())

	return file
}

// line 通过 PC 返回对应源代码行号。
func (f Frame) line() int {
	fn := runtime.FuncForPC(f.pc())
	if fn == nil {
		return 0
	}

	_, line := fn.FileLine(f.pc())

	return line
}

// name 通过 PC 返回函数名称。
func (f Frame) name() string {
	fn := runtime.FuncForPC(f.pc())
	if fn == nil {
		return _unknown
	}

	return fn.Name()
}

// 在 go 中，单引号表示单个字符，双引号表示字符串，是字符序列，反引号表示原始字符串。
// [优先使用 strconv 而不是 fmt](https://github.com/xxjwxc/uber_go_guide_cn#%E4%BC%98%E5%85%88%E4%BD%BF%E7%94%A8-strconv-%E8%80%8C%E4%B8%8D%E6%98%AF-fmt)

// Format 实现了 fmt.Formatter 接口，控制如何解释 fmt.State 和 rune ，
// 参考[Formatter](https://pkg.go.dev/fmt#Formatter)。
//
//	%s    源文件；
//	%d    行号；
//	%n    函数名；
//	%v    等同于 %s:%d ；
//	%+s   以 \n\t 分隔的函数名和相对于 GOPATH 源文件路径；
//	%+v   等同于 %+s:%d ；
//
// 详细信息在示例中查看。
func (f Frame) Format(s fmt.State, verb rune) {
	switch verb {
	case 's':
		switch {
		case s.Flag('+'):
			io.WriteString(s, f.name())
			io.WriteString(s, "\n\t")
			io.WriteString(s, f.file())
		default:
			io.WriteString(s, path.Base(f.file()))
		}
	case 'd':
		io.WriteString(s, strconv.Itoa(f.line()))
	case 'n':
		io.WriteString(s, funcname(f.name()))
	case 'v':
		f.Format(s, 's')
		io.WriteString(s, ":")
		f.Format(s, 'd')
	}
}

// MarshalText 将栈追踪信息输出为文本字符串。
func (f Frame) MarshalText() ([]byte, error) {
	name := f.name()
	if name == _unknown {
		return []byte(name), nil
	}

	return []byte(fmt.Sprintf("%s %s:%d", name, f.file(), f.line())), nil
}

// StackTrace 是从内层到外层的调用栈。
type StackTrace []Frame

// Format 实现了 fmt.Formatter 接口，控制如何解释 fmt.State 和 rune ，
//
//	%s    列出栈中每个 Frame 的文件路径；
//	%v    列出栈中每个 Frame 的文件路径和行号；
//	%+v   打印栈中每个 Frame 的文件名、函数名和行号；
//	%#v   以 go 语法形式打印；
//
// 详细信息在示例中查看。
func (st StackTrace) Format(s fmt.State, verb rune) {
	switch verb {
	case 'v':
		switch {
		case s.Flag('+'):
			for _, f := range st {
				io.WriteString(s, "\n")
				f.Format(s, verb)
			}
		case s.Flag('#'):
			fmt.Fprintf(s, "%#v", []Frame(st))
		default:
			st.formatSlice(s, verb)
		}
	case 's':
		st.formatSlice(s, verb)
	}
}

// formatSlice 列出栈中每个 Frame 的文件路径。
func (st StackTrace) formatSlice(s fmt.State, verb rune) {
	io.WriteString(s, "[")
	for i, f := range st {
		if i > 0 {
			io.WriteString(s, " ")
		}
		f.Format(s, verb)
	}
	io.WriteString(s, "]")
}

// stack 仅存储 PC ，而不是栈信息。
type stack []uintptr

// Format 实现了 fmt.Formatter 接口，控制如何解释 fmt.State 和 rune ：
//
//	%v+    打印栈中每个 Frame 的全部信息；
//	%v-    打印栈中每个 Frame 的栈顶，更加简洁；
func (s *stack) Format(st fmt.State, verb rune) {
	switch verb {
	case 'v':
		switch {
		case st.Flag('+'):
			for _, pc := range *s {
				f := Frame(pc)
				fmt.Fprintf(st, "\n%+v", f)
			}
		case st.Flag('-'):
			for _, pc := range *s {
				f := Frame(pc)
				fmt.Fprintf(st, "\n%+v", f)
				break
			}
		}
	}
}

// StackTrace 从 CP 数组返回由 Frame 组成的调用栈数组。
func (s *stack) StackTrace() StackTrace {
	f := make([]Frame, len(*s))
	for i := 0; i < len(f); i++ {
		f[i] = Frame((*s)[i])
	}
	return f
}

// callers 收集当前 goroutine （即调用 callers 函数的 goroutine ）栈上函数调用
// 返回的 PC 。
func callers() *stack {
	const depth = 32
	var pcs [depth]uintptr
	n := runtime.Callers(3, pcs[:])
	var st stack = pcs[0:n]
	return &st
}

// funcname 返回路径前缀后的函数名称。
func funcname(name string) string {
	i := strings.LastIndex(name, "/")
	name = name[i+1:]
	i = strings.Index(name, ".")
	return name[i+1:]
}
